package kafka

import (
	"errors"
	"webGoDemo/presenter"
)

//import (
//	"cmq-console-api/api/presenter"
//	"cmq-console-api/pkg/entity"
//	"cmq-console-api/pkg/entity/kafka"
//	"cmq-console-api/pkg/entity/mq"
//	"errors"
//	"fmt"
//	"time"
//)

var resourceClassMap map[string]bool

func init() {
	resourceClassMap = map[string]bool{"cmq.kafka.small": true, "cmq.kafka.middle": true, "cmq.kafka.large": true, "cmq.kafka.huge": true}
}

//type CreateClusterRequest struct {
//	// cluster 字段
//	ClusterName string         `json:"clusterName" description:"集群名,默认为空" optional:"true"`
//	ZoneCode    string         `json:"zoneCode" description:"可用区,默认为空" optional:"true"`
//	RegionCode  string         `json:"regionCode" description:"地域，默认为空" optional:"true"`
//	TenantType  uint8          `json:"tenantType" description:"租户类型,0:普通租户，1:产品租户,默认为0" optional:"true"`
//	IsMini      *bool          `json:"isMini" description:"是否为mini系列, 默认为是" optional:"true"`
//	NetworkType mq.NetworkType `json:"networkType" description:"网络类型, default:管理网即calico网络, vpc:业务网即ovn网络，默认为default" optional:"true"`
//	DiskType    mq.DiskType    `json:"diskType" description:"磁盘类型, ssd:SSD, ebs:高效云盘，默认为ebs" optional:"true"`
//
//	// cluster_detail 字段
//	IsSSl            uint8  `json:"isSSl" description:"是否SSL加密，0:不加密，1:加密，默认为0" optional:"true"`
//	Subnet           string `json:"subnet" description:"子网，默认为空，vpc网络为必填" optional:"true"`
//	IPList           string `json:"ipList" description:"vpc的ip值, 非vpc网络为空, 默认为空" option:"true"`
//	ResourceClass    string `json:"resourceClass" description:"规格,cmq.kafka.small, cmq.kafka.middle, cmq.kafka.large, cmq.kafka.huge"`
//	MsgRetentionHour uint32 `json:"msgRetentionHour" description:"消息最大保存时间，单位小时, 默认7*24小时" optional:"true"`
//	MaxTopicNumber   uint32 `json:"maxTopicNumber" description:"最大主题数量，默认200 (minikafka可自动创建主题，此值不用填)" optional:"true"`
//	MqVersion        string `json:"mqVersion" description:"版本, 默认2.4.0" optional:"true"`
//	Remark           string `json:"remark" description:"备注，默认为空" optional:"true"`
//	SaslEnable       uint8  `json:"saslEnable" description:"是否开启SASL加密，0:不加密，1:加密，默认为0" optional:"true"`
//	SaslUsers        string `json:"saslUsers" description:"SASL认证用户名" optional:"true"`
//	SaslPasswords    string `json:"saslPasswords" description:"SASL认证密码" optional:"true"`
//	Storage          uint32 `json:"storage" description:"磁盘容量，单位G" optional:"true"`
//	NetworkUid       string `json:"networkUid" description:"vpcID"`
//}
//
//type DeleteClusterRequest struct {
//	InstanceID string `json:"instanceID" description:"实例ID"`
//}

//func (c CreateClusterRequest) InitCluster(tenantID string) *kafka.Cluster {
//	now := time.Now()
//	clusterID := entity.GenerateID()
//	clusterType := mq.MiniKafka
//	if c.IsMini != nil && !*c.IsMini {
//		clusterType = mq.Kafka
//	}
//	return &kafka.Cluster{
//		ClusterMeta: mq.ClusterMeta{
//			ClusterID:   clusterID,
//			ClusterName: c.ClusterName,
//			TenantID:    tenantID,
//			TenantType:  c.TenantType,
//			ZoneCode:    c.ZoneCode,
//			RegionCode:  c.RegionCode,
//			ClusterType: clusterType,
//			NetworkType: c.NetworkType,
//			DiskType:    c.DiskType,
//			CreateTime:  now.Unix(),
//			UpdateTime:  now.Unix(),
//		},
//		ClusterDetail: kafka.ClusterDetail{
//			BrokerListVPC:    c.IPList,
//			ClusterID:        clusterID,
//			Subnet:           c.Subnet,
//			NetworkUid:       c.NetworkUid,
//			ResourceClass:    c.ResourceClass,
//			MsgRetentionHour: c.MsgRetentionHour,
//			MaxTopicNumber:   c.MaxTopicNumber,
//			MqVersion:        c.MqVersion,
//			IsSSl:            c.IsSSl,
//			Remark:           c.Remark,
//			SaslEnable:       c.SaslEnable,
//			SaslUsers:        c.SaslUsers,
//			SaslPasswords:    c.SaslPasswords,
//			Storage:          c.Storage,
//			CreateTime:       now.Unix(),
//			UpdateTime:       now.Unix(),
//		},
//		ClusterSummary: kafka.ClusterSummary{
//			ClusterID:        clusterID,
//			TopicNum:         0,
//			ConsumerGroupNum: 0,
//			PartitionNum:     0,
//			CreateTime:       now.Unix(),
//			UpdateTime:       now.Unix(),
//		},
//	}
//}

//func (c *CreateClusterRequest) Validate() error {
//	if c.Storage == 0 {
//		c.Storage = 1
//	}
//	if c.MsgRetentionHour == 0 {
//		c.MsgRetentionHour = 7 * 24
//	}
//	if len(c.MqVersion) == 0 {
//		c.MqVersion = "2.4.0"
//	}
//	if len(c.NetworkType) == 0 {
//		c.NetworkType = mq.NetworkCalico
//	}
//
//	if c.MsgRetentionHour < 24 || c.MsgRetentionHour > 168 {
//		//return errors.New("msgRetentionHour" + presenter.ParamLengthErr.Error() + ",消息保留时长应为24-168小时")
//		return errors.New("消息保留时长应为24-168小时，请重新输入")
//	}
//	if c.MaxTopicNumber == 0 {
//		c.MaxTopicNumber = 200
//	}
//	if c.MaxTopicNumber < 0 {
//		return errors.New("maxTopicNumber参数不能为空且大于0")
//	}
//	if c.NetworkType != mq.NetworkCalico && c.NetworkType != mq.NetworkOvn {
//		return errors.New("networkType参数只能为default，vpc")
//	}
//	if c.IsSSl != 0 && c.IsSSl != 1 {
//		return errors.New("isSSl参数只能为0，1，即只能为关闭或开启")
//	}
//	if c.SaslEnable != 0 && c.SaslEnable != 1 {
//		return errors.New("saslEnable参数只能为0，1，即只能为关闭或开启")
//	}
//	if c.SaslEnable == 1 && (len(c.SaslUsers) == 0 || len(c.SaslPasswords) == 0) {
//		return errors.New("sasl开启时，用户名和密码不能为空")
//	}
//	if len(c.ResourceClass) == 0 {
//		return presenter.ErrParamEmpty("resourceClass")
//	}
//
//	//字符串长度校验
//	if len(c.ClusterName) != 0 {
//		if len([]rune(c.ClusterName)) > 64 || len([]rune(c.ClusterName)) < 3 {
//			return errors.New("clusterName" + presenter.ParamLengthErr.Error() + ",集群名长度范围应为3-64字符")
//		}
//	}
//
//	if len([]rune(c.Remark)) > 500 {
//		return errors.New("remark" + presenter.ParamLengthErr.Error() + ",备注长度范围应为1-500字符")
//	}
//
//	//规格校验
//	ok := resourceClassMap[c.ResourceClass]
//	if !ok {
//		return errors.New("规格应为cmq.kafka.small, cmq.kafka.middle, cmq.kafka.large, cmq.kafka.huge")
//	}
//	//vpc网络的subnet校验
//	if c.NetworkType == mq.NetworkOvn && len(c.Subnet) == 0 {
//		return errors.New("vpc网络subnet参数不能为空")
//	}
//
//	// 租户类型校验  "租户类型,0:普通租户，1:产品租户,默认为0"
//	if c.TenantType != 0 && c.TenantType != 1 {
//		return errors.New("未知的租户类型 ！请使用正确的租户类型 ，0:普通租户，1:产品租户,默认为0")
//	}
//
//	return nil
//}

type UpdateClusterRequest struct {
	// cluster 字段
	ClusterName string `json:"clusterName" description:"集群名" optional:"true"`

	//cluster_detail 字段
	Remark           string `json:"remark" description:"备注" optional:"true"`
	ResourceClass    string `json:"resourceClass" description:"规格,cmq.kafka.small, cmq.kafka.middle, cmq.kafka.large, cmq.kafka.huge。此操作会重启服务" optional:"true"`
	MsgRetentionHour uint32 `json:"msgRetentionHour" description:"消息最大保存时间，单位小时，取值范围24-168。此操作会重启服务" optional:"true"`
}

//func CheckUpdate(updateClusterRequest UpdateClusterRequest, clusterGet *kafka.Cluster) (bool, error) {
//	isChange := false
//	if len(updateClusterRequest.ClusterName) != 0 && updateClusterRequest.ClusterName != clusterGet.ClusterName {
//		//return false, fmt.Errorf("集群名称修改没有变化")
//		isChange = true
//	}
//	if len(updateClusterRequest.ResourceClass) != 0 && updateClusterRequest.ResourceClass != clusterGet.ResourceClass {
//		//return false, fmt.Errorf("规格修改没有变化")
//		isChange = true
//	}
//	if updateClusterRequest.MsgRetentionHour != 0 && updateClusterRequest.MsgRetentionHour != clusterGet.MsgRetentionHour {
//		//return false, fmt.Errorf("消息保留时长修改没有变化")
//		isChange = true
//	}
//	if len(updateClusterRequest.Remark) != 0 && updateClusterRequest.Remark != clusterGet.Remark {
//		//return false, fmt.Errorf("备注修改没有变化")
//		isChange = true
//	}
//	if isChange {
//		return true, nil
//	}
//	return false, fmt.Errorf("没有修改内容")
//}
//func (u UpdateClusterRequest) InitCluster(clusterID entity.ID) *kafka.Cluster {
//	now := time.Now()
//	return &kafka.Cluster{
//		ClusterMeta: mq.ClusterMeta{
//			ClusterID:   clusterID,
//			ClusterName: u.ClusterName,
//			UpdateTime:  now.Unix(),
//		},
//		ClusterDetail: kafka.ClusterDetail{
//			ClusterID:        clusterID,
//			Remark:           u.Remark,
//			ResourceClass:    u.ResourceClass,
//			MsgRetentionHour: u.MsgRetentionHour,
//			UpdateTime:       now.Unix(),
//		},
//	}
//}

func (u UpdateClusterRequest) Validate() error {
	//字符串长度校验
	if len(u.ClusterName) != 0 {
		if len([]rune(u.ClusterName)) > 64 || len([]rune(u.ClusterName)) < 3 {
			return errors.New("clusterName" + presenter.ParamLengthErr.Error() + ",集群名长度范围应为3-64字符")
		}
	}

	//规格校验
	if len(u.ResourceClass) != 0 {
		ok := resourceClassMap[u.ResourceClass]
		if !ok {
			return errors.New("规格应为cmq.kafka.small, cmq.kafka.middle, cmq.kafka.large, cmq.kafka.huge")
		}
	}

	if u.MsgRetentionHour != 0 && (u.MsgRetentionHour < 24 || u.MsgRetentionHour > 168) {
		//return errors.New("msgRetentionHour" + presenter.ParamLengthErr.Error() + ",消息保留时长应为24-168小时")
		return errors.New("消息保留时长应为24-168小时，请重新输入")
	}
	if len([]rune(u.Remark)) > 500 {
		return errors.New("remark" + presenter.ParamLengthErr.Error() + ",备注长度范围应为1-500字符")
	}
	return nil
}



// 构建op 访问的请求体

//func (u UpdateClusterRequest) InitCluster(clusterID entity.ID) *kafka.Cluster {
//	now := time.Now()
//	return &kafka.Cluster{
//		ClusterMeta: mq.ClusterMeta{
//			ClusterID:   clusterID,
//			ClusterName: u.ClusterName,
//			UpdateTime:  now.Unix(),
//		},
//		ClusterDetail: kafka.ClusterDetail{
//			ClusterID:        clusterID,
//			Remark:           u.Remark,
//			ResourceClass:    u.ResourceClass,
//			MsgRetentionHour: u.MsgRetentionHour,
//			UpdateTime:       now.Unix(),
//		},
//	}
//}

//云资源中心查询数据请求参数
type CloudKafkaRequest struct {
	Num       int32  `json:"num"`
	BeginTime string `json:"beginTime"`
}
type YgKafkaRequest struct {
	InstanceID string `json:"instanceID"`
	PageNum    int64  `json:"pageNum"`
	PageSize   int64  `json:"pageSize"`
}

type OperateKafkaRequest struct {
}

func (c CloudKafkaRequest) Validate() error {
	return nil
}
